"""飞书多维表格服务"""

import os
import sys
from pathlib import Path
from typing import List, Dict, Any, Optional
import json
import time
from datetime import datetime
from utils.logger import sync_logger
from utils.db_utils import Database
from config.db_config import FEISHU_DB_CONFIG
from config.feishu_config import (
    FEISHU_TABLE_URLS, 
    parse_feishu_url, 
    get_table_name
)
from services.feishu_service import FeishuService

class FeishuTableService:
    """飞书多维表格服务类，支持动态建表和同步数据"""
    
    def __init__(self, db_config=None):
        """初始化服务"""
        self.db = Database(
            host=db_config['host'] if db_config else FEISHU_DB_CONFIG['host'], 
            port=db_config['port'] if db_config else FEISHU_DB_CONFIG['port'], 
            user=db_config['user'] if db_config else FEISHU_DB_CONFIG['user'], 
            password=db_config['password'] if db_config else FEISHU_DB_CONFIG['password'], 
            database=db_config['database'] if db_config else FEISHU_DB_CONFIG['database']
        )
        self.db.connect()
        self.feishu_service = FeishuService()
        
    def __del__(self):
        """析构函数"""
        if hasattr(self, 'db'):
            self.db.disconnect()
            
    def process_all_tables(self):
        """遍历所有URL，动态建表并同步数据"""
        # 记录处理结果
        success_count = 0
        fail_count = 0
        total_count = len(FEISHU_TABLE_URLS)
        
        sync_logger.log_info(f"开始处理飞书多维表格，共 {total_count} 张表格")
        
        for url in FEISHU_TABLE_URLS:
            try:
                sync_logger.log_info(f"处理URL: {url}")
                config = parse_feishu_url(url)
                app_token = config['app_token']
                table_id = config['table_id']
                
                # 使用新的表名获取函数
                sync_logger.log_info(f"获取表格 {table_id} 的表名")
                table_name = get_table_name(table_id)
                
                # 确保表名是有效的MySQL表名
                if not table_name:
                    table_name = f"feishu_{table_id}"
                    sync_logger.log_warning(f"表格 {table_id} 没有有效的表名，使用默认表名: {table_name}")
                
                # 处理表名，移除特殊字符，只保留中文、英文、数字和下划线
                import re
                table_name = re.sub(r'[^\w\u4e00-\u9fff]', '_', table_name)
                # 确保表名以字母开头（MySQL要求）
                if not table_name[0].isalpha():
                    table_name = f"t_{table_name}"
                    sync_logger.log_info(f"表格名添加 t_ 前缀: {table_name}")
                
                sync_logger.log_info(f"开始处理表格: {table_name}【{table_id}】")
                
                # 获取字段信息
                try:
                    fields = self.feishu_service.get_table_fields_by_token(app_token, table_id)
                    sync_logger.log_info(f"成功获取到 {len(fields)} 个字段")
                except Exception as e:
                    sync_logger.log_error(f"获取表格 {table_id} 字段信息失败: {str(e)}")
                    fail_count += 1
                    continue
                
                # 获取数据
                try:
                    records = self.feishu_service.get_table_records_by_token(app_token, table_id)
                    sync_logger.log_info(f"成功获取到 {len(records)} 条记录")
                except Exception as e:
                    sync_logger.log_error(f"获取表格 {table_id} 数据失败: {str(e)}")
                    fail_count += 1
                    continue
                
                # 动态建表（使用数据第一条记录为样本）
                try:
                    if records:
                        self.create_table_with_samples(table_name, fields, records[0])
                    else:
                        self.db.create_table(table_name, fields)
                    sync_logger.log_info(f"成功创建表格 {table_name}")
                except Exception as e:
                    sync_logger.log_error(f"创建表格 {table_name} 失败: {str(e)}")
                    fail_count += 1
                    continue
                
                # 写入数据库
                try:
                    self.save_table_data(table_name, records, fields)
                    sync_logger.log_info(f"表格 {table_name} 处理完成")
                    success_count += 1
                except Exception as e:
                    sync_logger.log_error(f"保存表格 {table_name} 数据失败: {str(e)}")
                    fail_count += 1
                    continue
            except Exception as e:
                sync_logger.log_error(f"处理表格 {url} 失败: {str(e)}")
                fail_count += 1
                continue
        
        # 汇总处理结果
        sync_logger.log_info(f"飞书多维表格处理完成: 成功 {success_count} 张, 失败 {fail_count} 张, 总计 {total_count} 张")
                
    def create_table_with_samples(self, table_name: str, fields: List[Dict[str, Any]], sample_record: Dict[str, Any]):
        """根据样本数据创建表
        
        Args:
            table_name: 表名
            fields: 字段列表
            sample_record: 样本记录
        """
        # 增强字段定义，添加样本值
        enhanced_fields = []
        for field in fields:
            field_name = field.get('field_name') or field.get('name')
            enhanced_field = field.copy()
            # 添加样本值
            if field_name in sample_record:
                enhanced_field['sample_value'] = sample_record[field_name]
            enhanced_fields.append(enhanced_field)
            
        # 创建表
        self.db.create_table(table_name, enhanced_fields)
                
    def save_table_data(self, table_name: str, data: List[Dict[str, Any]], fields: List[Dict[str, Any]]):
        """保存表格数据到数据库
        
        Args:
            table_name: 表名
            data: 数据列表
            fields: 字段配置
        """
        if not data:
            sync_logger.log_info(f"表格 {table_name} 没有新数据")
            return
            
        try:
            # 调试日志，打印第一条数据的所有字段
            if data:
                sync_logger.log_info(f"数据结构示例: {data[0].keys()}")
                sync_logger.log_info(f"数据示例: {data[0]}")
                
            # 准备字段名列表
            field_names = [field['field_name'] for field in fields]
            
            # 找到业务主键字段，后面用于生成索引
            id_field = None
            for key in data[0].keys():
                if key.lower() in ['record_id', 'id', '_id', 'recordid', '编号']:
                    id_field = key
                    sync_logger.log_info(f"使用 {id_field} 作为业务主键字段")
                    break
                    
            # 预处理数据，将复杂类型转换为字符串
            processed_data = []
            for record in data:
                processed_record = {}
                # 添加原始字段
                for key, value in record.items():
                    # 如果是字典或列表，转换为JSON字符串
                    if isinstance(value, (dict, list)):
                        processed_record[key] = json.dumps(value, ensure_ascii=False)
                    else:
                        processed_record[key] = value
                processed_data.append(processed_record)
                
            # 批量保存数据
            self.db._batch_save(
                table=table_name,
                data=processed_data,
                id_field='id',  # 使用自增ID作为主键
                fields=field_names,
                values_func=lambda x: [x.get(field, None) for field in field_names]
            )
            
        except Exception as e:
            sync_logger.log_error(f"保存表格 {table_name} 数据时发生错误: {str(e)}")
            raise 